from race.Player import *
import logging.config
from threadJob import *
from pynput.mouse import Controller as mController
from pynput.keyboard import Controller as kController
from pynput.keyboard import Key
import functools
import numpy

logging.config.fileConfig('./util/logging.conf')
log = logging.getLogger("example")

"""
    子类描述：
        1、武僧坦克类
"""


class TankMonk(Player):

    def on_keyboard_press_son_before_thread(self, key):
        log.debug("on_keyboard_press_son_before_thread 1:进入了函数")
        # 有些按键是直接终止别人的，继续自己的，有些不是这样的，因此要区别对待【排列组合，情况非常多】/【也要超级符合每个职业的操作习惯】
        if key in (
                Key.f1, Key.f2, Key.f3, Key.f4, Key.f5, Key.f6, Key.f7, Key.f8, Key.f9, Key.f10, Key.f11,
                Key.f12):
            pass
        elif key == Key.enter:
            pass
        elif key == Key.space:
            pass
        elif key == Key.alt_l:
            pass
        elif key == Key.ctrl_l:
            pass
        elif key == Key.caps_lock:
            pass
        elif key == Key.shift_l:
            pass
        elif key.char == 'a':
            # 不终止别人，后面让只允许一个线程执行的逻辑来顺序排
            # ★★★★★★|★★★★★★|★★★★★★|★★★★★★|★★★★★★|★★★★★★|★★★★★★|★★★★★★|★★★★★★|★★★★★★|
            # 并行并发执行的折中方案【通过触发其他按键，这样的好处是线程池统一管理了】
            pass
        elif key.char == 'z':
            pass
        elif key.char == 'q':
            pass
        elif key.char == 'w':
            # 终止掉别人
            self.interruptAllByForce()
        elif key.char == 'r':
            # 终止掉别人
            # interruptAllByForce()
            pass
        elif key.char == 'g':
            # 终止掉别人
            self.interruptAllByForce()
        elif key.char == 'x':
            # 终止掉别人
            self.interruptAllByForce()
        elif key.char == 'v':
            # 终止掉别人
            self.interruptAllByForce()
        elif key.char == 'h':
            # 终止掉别人
            self.interruptAllByForce()
        elif key.char == 'c':
            # 终止掉别人
            self.interruptAllByForce()
        elif key.char == 'e':
            pass
        elif key.char == 's':
            pass
        elif key.char == 'd':
            pass
        elif key.char == 'f':
            pass
        elif key.char == 'b':
            pass
        return

    # 执行父类的方法
    # @logAop
    def a(self):
        # 父类的方法先执行（或者后续看看是不是就直接用之类覆盖之后的方法）
        self.startScheduler1()  # 调用 CallBackScheduler1
        self.startScheduler2()  # 调用 CallBackScheduler2
        self.startScheduler3()  # 调用 CallBackScheduler3
        self.startScheduler4()  # 调用 CallBackScheduler3
        return

    def CallBackScheduler1(self):
        while self.ui.stopLoop == False:
            log.debug('天神酒:' + str(self.ui.stopLoop))
            if self.ui.checkBox_SM_Jump2Wolf.isChecked() == True:
                # *****天神酒*****
                self.pubAvgColorTiggerKeyBloodBarMode(self.WABloodBarX + self.WABloodBarWidth * 0.72, self.WABloodBarY,
                                                      self.WABloodBarDeltaX, self.WABloodBarDeltaY,
                                                      self.WABloodBarAvgColor, 'r', 'small', '4', 0.06, 4, '2')

                # 天神酒:2222222222222222z在叠加层数的真气消失前使用这个真气，不用掉，就会消失掉，就浪费了（具体的几秒，在za中进行控制）
                self.pubAvgColorTiggerKeyBuffMode(self.WA_SQUARE_ZFX_X4, self.WA_SQUARE_ZFX, self.WABloodBarDeltaX,
                                                  self.WABloodBarDeltaY,
                                                  self.WA_SQUARE_ZFX_AvgColor,
                                                  'r', 'big', '4', 0.06, 3, '2')
            else:
                sleep(0.1)

            # # 猛虎掌（消耗能量,减酒类cd）
            # self.pubAvgColorTiggerKeyBuffMode(self.WA_SQUARE_ZFX_X5, self.WA_SQUARE_ZFX, self.WABloodBarDeltaX,
            #                                   self.WABloodBarDeltaY,
            #                                   self.WA_SQUARE_ZFX_AvgColor,
            #                                   'r', 'big', '1', 0.06, 2, '2')
            # 壮胆酒
            self.pubAvgColorTiggerKeyBloodBarMode(self.WABloodBarX + self.WABloodBarWidth * 0.4, self.WABloodBarY,
                                                  self.WABloodBarDeltaX, self.WABloodBarDeltaY,
                                                  self.WABloodBarAvgColor, 'r', 'small', 'o', 0.06, 4, '2')

    def CallBackScheduler2(self):
        while self.ui.stopLoop == False:
            # 武僧，红/绿/紫球的za插件定制（对右侧的第一个球，只要不是绿的，红和紫色，都吃一瓶酒）(2瓶有空余的时候喝)
            self.pubAvgColorTiggerKeyBloodBarMode(767, 423,
                                                  self.WABloodBarDeltaX, self.WABloodBarDeltaY,
                                                  10, 'g', 'small', '5', 0.06, 2, '2')

            # za的武僧T插件，在快红了的时候喝（不喝就大掉血，危险）
            realColor = self.pubAvgColorTiggerKeyBloodBarMode(self.WA_WST_X, self.WA_WST_Y,
                                                              self.WA_WST_W, self.WA_WST_H,
                                                              self.WA_WST_AVG_COLOR, 'r', 'big', '5', 0.06, 2, '2')
            log.debug('轻松:轻松:' + str(self.WA_WST_X) + ',' + str(self.WA_WST_Y) + ',' + str(self.WA_WST_W) + ',' + str(
                self.WA_WST_H) + ':color:' + str(self.WA_WST_AVG_COLOR) + ',realColor:' + str(realColor))
            sleep(0.2)
        return

    def CallBackScheduler3(self):
        while self.ui.stopLoop == False:
            # # 神鹤踢（消耗能量）
            # self.pubAvgColorTiggerKeyBuffMode(self.WA_SQUARE_ZFX_X5, self.WA_SQUARE_ZFX, self.WABloodBarDeltaX,
            #                                   self.WABloodBarDeltaY,
            #                                   self.WA_SQUARE_ZFX_AvgColor,
            #                                   'r', 'big', '[', 0.06, 2, '2')

            # 移花接木
            self.pubAvgColorTiggerKeyBloodBarMode(self.WABloodBarX + self.WABloodBarWidth * 0.8, self.WABloodBarY,
                                                  self.WABloodBarDeltaX, self.WABloodBarDeltaY,
                                                  self.WABloodBarAvgColor, 'r', 'small', '9', 0.06, 4, '2')
            # 骨尘酒
            self.pubAvgColorTiggerKeyBloodBarMode(self.WABloodBarX + self.WABloodBarWidth * 0.8, self.WABloodBarY,
                                                  self.WABloodBarDeltaX, self.WABloodBarDeltaY,
                                                  self.WABloodBarAvgColor, 'r', 'small', ']', 0.06, 4, '2')

            # 扫堂腿
            self.pubAvgColorTiggerKeyBloodBarMode(self.WABloodBarX + self.WABloodBarWidth * 0.6, self.WABloodBarY,
                                                  self.WABloodBarDeltaX, self.WABloodBarDeltaY,
                                                  self.WABloodBarAvgColor, 'r', 'small', 'k', 0.06, 4, '2')

            # 饰品1
            self.pubAvgColorTiggerKeyBloodBarMode(self.WABloodBarX + self.WABloodBarWidth * 0.5, self.WABloodBarY,
                                                  self.WABloodBarDeltaX, self.WABloodBarDeltaY,
                                                  self.WABloodBarAvgColor, 'r', 'small', 'i', 0.06, 4, '2')
            # 饰品2
            self.pubAvgColorTiggerKeyBloodBarMode(self.WABloodBarX + self.WABloodBarWidth * 0.4, self.WABloodBarY,
                                                  self.WABloodBarDeltaX, self.WABloodBarDeltaY,
                                                  self.WABloodBarAvgColor, 'r', 'small', 't', 0.06, 4, '2')
            # 饰品2
            self.pubAvgColorTiggerKeyBloodBarMode(self.WABloodBarX + self.WABloodBarWidth * 0.4, self.WABloodBarY,
                                                  self.WABloodBarDeltaX, self.WABloodBarDeltaY,
                                                  self.WABloodBarAvgColor, 'r', 'small', 'p', 0.06, 4, '2')
        return

    def CallBackScheduler4(self):
        while self.ui.stopLoop == False:
            self.click(self.kb, '2', 3)
            sleep(0.1)
            self.click(self.kb, 'l', 2)
            sleep(0.1)
            self.click(self.kb, '8', 2)
            sleep(0.1)
            self.click(self.kb, '3', 2)
            sleep(0.1)
        return

    def r(self):
        # 父类的方法先执行（或者后续看看是不是就直接用之类覆盖之后的方法）
        # super().a()
        pass
        return

    def b(self):
        # 父类的方法先执行（或者后续看看是不是就直接用之类覆盖之后的方法）
        # super().a()
        pass
        return

    def mouseUp(self, x, y):
        for i in range(1, 10):
            log.debug('★TankMonk鼠标r，【月饼节】需要开始执行的内容★')
            sleep(0.2)
            self.click(self.kb, '4', 2)

    def mouseDown(self, x, y):

        # 活血酒
        for i in range(1, 3):
            self.click(self.kb, '5', 2)
            sleep(0.1)

    def on_mouse_click_son_before_thread(self, x, y, button, pressed):
        # 在鼠标点击，终止和打断其他动作（有些职业需要，有些不需要）??????????
        pass
        return

    def parallelAlt2(self):
        loopCount = 0
        self.Button1DeltaX = 5
        self.Button1DeltaY = 5
        while True:
            sleep(2.2)

    def x(self):
        for i in range(1, 4):
            self.click(self.kb, 'n', 2)
            sleep(0.1)

        # 打断后的继续
        self.click(self.kb, 'a', 1)
        return


"""
    子类描述：
        1、武僧治疗类
"""


class HealMonk(Player):

    def on_mouse_scroll_son_before_thread(self, dx, dy):
        # if dy < 0:
        #     # 滚轮向下
        #     log.debug('★HealMonk鼠标on_mouse_scroll_son_before_thread，需要开始执行的内容★')
        #     self.interruptAllByForceMouseUpDown()
        # elif dy > 0:
        #     # 滚轮向上
        #     self.interruptAllByForceMouseUpDown()
        #     log.debug('★HealMonk鼠标on_mouse_scroll_son_before_thread，需要over执行的内容★')
        pass
        return

    def a(self):
        # log.debug("HealMonk踢怪物省蓝开始")
        # # 选中一个怪物，题一脚，这样来节约回蓝
        # self.click(self.kb, Key.tab, 1)
        # sleep(0.08)
        # self.click(self.kb, "9", 3)
        # sleep(0.08)
        # self.click(self.kb, "0", 3)
        # log.debug("HealMonk踢怪物省蓝Over")
        # 【奶僧】的特殊手法，在鼠标左键点击的时候，连续的结果动作（原来在原版按键精灵中，是极其容易死机的）
        log.debug('★HealMonk鼠标mouseLeftClick，需要开始执行的内容★')
        sleep(0.1)  # 这个不等0.2秒都不行，1没法输出到notepad中
        self.click(self.kb, '1', 6)  # 抚慰之雾(毛线)
        sleep(0.3)  # 第二个技能(氤氲之雾)会变瞬发技能，因此这个等待时间非常重要，多次测试出来的。【★★★★★】
        self.click(self.kb, '3', 9)  # 拉毛线后补的这个瞬发(氤氲之雾)buff
        log.debug('★HealMonk鼠标mouseLeftClick，需要over执行的内容★')
        return

    def q(self):
        # 【奶僧】 驱散
        for i in range(1, 4):
            self.click(self.kb, 'k', 6)  # 活血术，抬群血
            sleep(0.2)
        return

    # def mouseLeftClick(self, x, y):
    #     # if x > 400 and y > 400 and x < 600 and y < 600:
    #     # 【奶僧】的特殊手法，在鼠标左键点击的时候，连续的结果动作（原来在原版按键精灵中，是极其容易死机的）
    #     log.debug('★HealMonk鼠标mouseLeftClick，需要开始执行的内容★')
    #     sleep(0.1)  # 这个不等0.2秒都不行，1没法输出到notepad中
    #     self.click(self.kb, '1', 6)  # 抚慰之雾(毛线)
    #     sleep(0.3)  # 第二个技能(氤氲之雾)会变瞬发技能，因此这个等待时间非常重要，多次测试出来的。【★★★★★】
    #     self.click(self.kb, '3', 9)  # 拉毛线后补的这个瞬发(氤氲之雾)buff
    #     log.debug('★HealMonk鼠标mouseLeftClick，需要over执行的内容★')
    #     return

    # def mouseLeftClickNoThread(self, x, y, pressed):
    #     self.click(self.kb, '1', 6)  # 抚慰之雾(毛线)
    #     sleep(0.3)  # 第二个技能(氤氲之雾)会变瞬发技能，因此这个等待时间非常重要，多次测试出来的。【★★★★★】
    #     self.click(self.kb, '3', 9)  # 拉毛线后补的这个瞬发(氤氲之雾)buff
    #     return

    def mouseRightClick(self, x, y):
        if x > 400 and y > 400 and x < 600 and y < 600:
            # 【奶僧】的特殊手法，在鼠标左键点击的时候，连续的结果动作（原来在原版按键精灵中，是极其容易死机的）
            for i in range(1, 4):
                self.click(self.kb, 'k', 6)  # 活血术，抬群血
                sleep(0.2)
                # # `self.click(self.kb, '5', 3)  # 开其他饰品，协助抬群血
                # self.click(self.kb, '\\', 3)  # 开其他饰品，协助抬群血
                # self.click(self.kb, '[', 3)  # 开其他饰品，协助抬群血
        return

    def mouseUp(self, x, y):
        log.debug('★HealMonk鼠标mouseUp，需要开始执行的内容★')
        self.click(self.kb, '4', 6)  # 精华之泉
        log.debug('★HealMonk鼠标mouseUp，需要over执行的内容★')
        return

    def mouseDown(self, x, y):
        log.debug('★HealMonk鼠标mouseDown，需要开始执行的内容★')
        for i in range(1, 888888):
            self.click(self.kb, '6', 6)  # 活血术，抬群血
            sleep(0.08)
            # # `self.click(self.kb, '5', 3)  # 开其他饰品，协助抬群血
            # self.click(self.kb, '\\', 3)  # 开其他饰品，协助抬群血
            # self.click(self.kb, '[', 3)  # 开其他饰品，协助抬群血
        log.debug('★HealMonk鼠标mouseDown1，需要over执行的内容★')
        return

    def mouseMove(self, x, y):
        log.debug('mouseMovemouseMovemouseMove')
        strTempDate = int(datetime.datetime.now().strftime('%S'))
        if strTempDate % 2 == 0:
            self.click(self.kb, '2', 2)
        return

    def schedulerAction(self):
        # 通过定时器，固定多少秒执行一次
        self.countPlusPlus = self.countPlusPlus + 1
        log.debug('schedulerAction:HealMonk*****HealMonk')
        if self.ui.checkBox_SM_Jump2Wolf.isChecked():
            # self.click(self.kb, '2', 4)
            # 提前有【复苏之雾】的buff，活血术才会变成刷群血的技能
            if int(self.countPlusPlus) % 10 == 0:
                self.click(self.kb, Key.f3, 4)
            elif int(self.countPlusPlus) % 10 == 1:
                self.click(self.kb, Key.f4, 4)
            elif int(self.countPlusPlus) % 10 == 2:
                self.click(self.kb, Key.f5, 4)
            elif int(self.countPlusPlus) % 10 == 3:
                self.click(self.kb, Key.f6, 4)
            elif int(self.countPlusPlus) % 10 == 4:
                self.click(self.kb, Key.f7, 4)
            elif int(self.countPlusPlus) % 10 == 5:
                self.click(self.kb, Key.f3, 4)
            elif int(self.countPlusPlus) % 10 == 6:
                self.click(self.kb, Key.f4, 4)
            elif int(self.countPlusPlus) % 10 == 7:
                self.click(self.kb, Key.f5, 4)
            elif int(self.countPlusPlus) % 10 == 8:
                self.click(self.kb, Key.f6, 4)
            elif int(self.countPlusPlus) % 10 == 9:
                self.click(self.kb, Key.f7, 4)
        return

    # def e(self):
    #     log.debug('HealMonk鼠标e，需要开始执行的内容★')
    #     #  提前有复苏之雾的buff，活血术才会变成刷群血的技能
    #     self.healMonkFuShuZhiWu()
    #     log.debug('HealMonk鼠标e，需要over执行的内容★')
    #     return

    # def s(self):
    #     log.debug('HealMonk鼠标s，需要开始执行的内容★')
    #     #  提前有复苏之雾的buff，活血术才会变成刷群血的技能
    #     self.healMonkFuShuZhiWu()
    #     log.debug('HealMonk鼠标s，需要over执行的内容★')
    #     return

    # def d(self):
    #     log.debug('HealMonk鼠标d，需要开始执行的内容★')
    #     #  提前有复苏之雾的buff，活血术才会变成刷群血的技能
    #     self.healMonkFuShuZhiWu()
    #     log.debug('HealMonk鼠标d，需要over执行的内容★')
    #     return

    # def f(self):
    #     log.debug('HealMonk鼠标f，需要开始执行的内容★')
    #     #  提前有复苏之雾的buff，活血术才会变成刷群血的技能
    #     self.healMonkFuShuZhiWu()
    #     log.debug('HealMonk鼠标f，需要over执行的内容★')
    #     return

    def healMonkFuShuZhiWu(self):
        # if self.ui.checkBox_SM_Jump2Wolf.isChecked() == True:
        #     # 提前有【复苏之雾】的buff，活血术才会变成刷群血的技能
        #     if int(str(datetime.datetime.now().strftime('%S'))[-1]) == 0:
        #         self.click(self.kb, Key.f3, 1)
        #         #sleep(1)
        #     elif int(str(datetime.datetime.now().strftime('%S'))[-1]) == 1:
        #         self.click(self.kb, Key.f4, 1)
        #         #sleep(1)
        #     elif int(str(datetime.datetime.now().strftime('%S'))[-1]) == 2:
        #         self.click(self.kb, Key.f5, 1)
        #         #sleep(1)
        #     elif int(str(datetime.datetime.now().strftime('%S'))[-1]) == 3:
        #         self.click(self.kb, Key.f6, 1)
        #         #sleep(1)
        #     elif int(str(datetime.datetime.now().strftime('%S'))[-1]) == 4:
        #         self.click(self.kb, Key.f7, 1)
        #         #sleep(1)
        #     elif int(str(datetime.datetime.now().strftime('%S'))[-1]) == 5:
        #         self.click(self.kb, Key.f3, 1)
        #         #sleep(1)
        #     elif int(str(datetime.datetime.now().strftime('%S'))[-1]) == 6:
        #         self.click(self.kb, Key.f4, 1)
        #         #sleep(1)
        #     elif int(str(datetime.datetime.now().strftime('%S'))[-1]) == 7:
        #         self.click(self.kb, Key.f5, 1)
        #         #sleep(1)
        #     elif int(str(datetime.datetime.now().strftime('%S'))[-1]) == 8:
        #         self.click(self.kb, Key.f6, 1)
        #         #sleep(1)
        #     elif int(str(datetime.datetime.now().strftime('%S'))[-1]) == 9:
        #         self.click(self.kb, Key.f7, 1)
        #         #sleep(1)
        return


class DpsMonk(Player):
    def a(self):
        # 父类的方法先执行（或者后续看看是不是就直接用之类覆盖之后的方法）
        # ★★★★★并行|并发★★★★★----------------parallel:`1   Alt2     cap3    shift4   ctrl5
        self.kb.press('`')  # 触发-->parallel1
        self.kb.release('`')

        self.kb.press(Key.alt_l)
        self.kb.release(Key.alt_l)

        self.kb.press(Key.caps_lock)
        self.kb.release(Key.caps_lock)

        self.kb.press(Key.ctrl_l)
        self.kb.release(Key.ctrl_l)

        self.kb.press(Key.ctrl_r)
        self.kb.release(Key.ctrl_r)

        self.Button1DeltaX = 2
        self.Button1DeltaY = 2
        loopCount = 0
        while self.ui.stopLoop == False:
            loopCount = loopCount + 1
            log.debug("ImageGrab图像抓取，像素识别前时分秒:" + str(datetime.datetime.now()))
            sleep(1.0)  # 避免CPU占用太高
            ################################Button1##########################################
            catchButton1X = 1165  # 抓取FiveStart的X起始位置(lastone)
            catchButton1Y = 1072  # 抓取FiveStart的Y起始位置(lastone)
            imButton1 = ImageGrab.grab(
                bbox=(catchButton1X, catchButton1Y, catchButton1X + self.Button1DeltaX,
                      catchButton1Y + self.Button1DeltaY))  # X1,Y1,X2,Y2
            imButton1_numpy = np.array(imButton1.getdata(), dtype='uint8').reshape(
                (imButton1.size[1], imButton1.size[0], 3))
            imButton1_pil = Image.fromarray(imButton1_numpy)
            rButton1, gButton1, bButton1 = imButton1_pil.split()  # 分离三通道
            rButton1.thumbnail((1, 1))  # 图片缩放为一个像素点
            avgButton1_color = rButton1.getpixel((0, 0))
            ################################End##########################################

            if avgButton1_color > 180:
                for i in range(1, 8):
                    self.click(self.kb, '\\', 3)
                    sleep(0.3)

    def parallel1(self):
        # 父类的方法先执行（或者后续看看是不是就直接用之类覆盖之后的方法）
        while self.ui.stopLoop == False:
            self.click(self.kb, '4', 3)
            sleep(0.08)
            self.click(self.kb, '2', 3)
            sleep(0.08)
            if int(str(datetime.datetime.now().strftime('%S'))[-1]) % 2 == 0:
                self.click(self.kb, '3', 2)
                sleep(0.08)
        return

    def parallelAlt2(self):
        # 父类的方法先执行（或者后续看看是不是就直接用之类覆盖之后的方法）
        while self.ui.stopLoop == False:
            self.click(self.kb, '1', 3)
            sleep(0.01)
            self.click(self.kb, '9', 3)
        return

    def parallelCap3(self):
        # 父类的方法先执行（或者后续看看是不是就直接用之类覆盖之后的方法）
        while self.ui.stopLoop == False:
            self.click(self.kb, '0', 3)
            sleep(0.01)
        return

    def parallelCtrl5(self):
        while self.ui.stopLoop == False:
            self.click(self.kb, '4', 3)
            sleep(0.1)
        return

    def parallelCtrl6(self):
        while self.ui.stopLoop == False:
            sleep(5)
        return

    def on_mouse_click_son_before_thread(self, x, y, button, pressed):
        # 避免点击鼠标，就立刻停止了
        pass
        return

    def mouseUp(self, x, y):
        log.debug('★鼠标向上滚，需要开始执行的内容★')
        for i in range(1, 10):
            self.click(self.kb, ']', 2)
            sleep(0.01)
            self.click(self.kb, ';', 2)
        log.debug('★鼠标向上滚，需要over执行的内容★')
        return

    def mouseDown(self, x, y):
        for i in range(1, 30):
            self.click(self.kb, 'n', 2)
            sleep(0.2)
        return

    def space(self):
        self.click(self.kb, 'k', 3)
        return


if __name__ == '__main__':
    pass
